// API基础URL，根据实际部署情况修改
const BASE_URL = 'https://www.thpws.cn/api';
// 媒体文件URL基础路径
const MEDIA_URL = 'https://www.thpws.cn';

// 输出服务器地址配置信息，用于调试
console.log('API服务器地址配置:', {
  BASE_URL: BASE_URL,
  MEDIA_URL: MEDIA_URL,
  配置时间: new Date().toISOString()
});

// 构建完整的媒体URL
const getFullImageUrl = (path) => {
  if (!path) return '';
  
  // 如果已经是完整URL，则直接返回
  if (path.startsWith('http://') || path.startsWith('https://')) {
    return path;
  }
  
  // 确保路径以/开头
  if (!path.startsWith('/')) {
    path = '/' + path;
  }
  
  console.log('原始图片路径:', path);
  const fullUrl = MEDIA_URL + path;
  console.log('完整图片URL:', fullUrl);
  return fullUrl;
};

// 检查登录状态
const checkLogin = () => {
  return new Promise((resolve, reject) => {
    const token = wx.getStorageSync('token');
    const userInfo = wx.getStorageSync('userInfo');
    
    if (token && userInfo) {
      resolve(userInfo);
    } else {
      // 获取当前页面路径，用于登录后重定向
      const pages = getCurrentPages();
      if (pages && pages.length > 0) {
        const currentPage = pages[pages.length - 1];
        const redirectUrl = `/${currentPage.route}`;
        
        // 如果没有登录，跳转到登录页
        wx.navigateTo({
          url: `/pages/login/login?redirect=${encodeURIComponent(redirectUrl)}`
        });
      } else {
        // 如果无法获取当前页面，直接跳转到登录页
        wx.navigateTo({
          url: '/pages/login/login'
        });
      }
      
      reject(new Error('未登录'));
    }
  });
};

// 请求函数
const request = (url, method, data) => {
  // 获取全局API配置，如果有的话
  const app = getApp();
  let serverUrl = BASE_URL;
  
  if (app && app.globalData && app.globalData.apiBaseUrl) {
    // 使用全局配置的API地址
    serverUrl = `${app.globalData.apiBaseUrl}/api`;
  }
  
  const fullUrl = `${serverUrl}${url}`;
  
  console.log(`发起请求: ${method} ${fullUrl}`, data);
  
  return new Promise((resolve, reject) => {
    // 获取存储的token
    const token = wx.getStorageSync('token');
    
    wx.request({
      url: fullUrl, // 使用完整的URL而非拼接
      method: method,
      data: data,
      header: {
        'Authorization': token ? `Token ${token}` : '',
        'Content-Type': 'application/json'
      },
      success: (res) => {
        // 请求成功
        if (res.statusCode >= 200 && res.statusCode < 300) {
          console.log(`请求成功: ${method} ${url}`, res.data);
          resolve(res.data);
        } else if (res.statusCode === 401) {
          // 未授权，可能是token过期
          console.error(`认证失败: ${method} ${url}`, res);
          wx.removeStorageSync('token');
          wx.removeStorageSync('userInfo');
          
          const app = getApp();
          app.globalData.userInfo = null;
          
          // 获取当前页面路径，用于登录后重定向
          const pages = getCurrentPages();
          const currentPage = pages[pages.length - 1];
          const redirectUrl = `/${currentPage.route}`;
          
          // 跳转到登录页面
          wx.navigateTo({
            url: `/pages/login/login?redirect=${encodeURIComponent(redirectUrl)}`
          });
          
          reject(new Error('登录已过期，请重新登录'));
        } else {
          // 其他错误
          let errorMsg = '请求失败';
          if (res.data && res.data.error) {
            errorMsg = res.data.error;
          } else if (res.data && typeof res.data === 'object') {
            // 尝试处理验证错误
            errorMsg = Object.entries(res.data)
              .map(([key, value]) => `${key}: ${Array.isArray(value) ? value.join(', ') : value}`)
              .join('; ');
          }
          
          console.error(`请求失败: ${method} ${url}`, {
            statusCode: res.statusCode,
            data: res.data,
            errMsg: res.errMsg
          });
          
          reject(new Error(`${errorMsg} (${res.statusCode})`));
        }
      },
      fail: (err) => {
        // 网络错误等
        console.error(`请求错误: ${method} ${url}`, err);
        // 提供网络失败的详细原因
        const errMsg = err.errMsg || '网络请求失败';
        reject(new Error(errMsg));
      }
    });
  });
};

// 需要登录的请求函数
const authRequest = (url, method, data) => {
  return checkLogin()
    .then(() => {
      return request(url, method, data);
    });
};

// API模块
const api = {
  // 工具函数
  getFullImageUrl,
  checkLogin,
  
  // 用户相关
  user: {
    // 微信登录
    login: (data) => {
      // 检查是否为模拟运行环境
      const isSimulator = typeof data.code === 'string' && 
                         (data.code.startsWith('the code is a mock') || data.code === 'mock');
      
      // 模拟登录时使用固定的openid
      if (isSimulator) {
        console.log('检测到模拟环境，使用固定用户信息');
        
        // 固定的模拟openid
        const mockOpenid = 'mock_openid_stable';
        
        // 构建微信信息
        const wxInfo = data.userInfo || {};
        
        // 构造模拟登录响应
        const mockResponse = {
          token: 'mock_token_' + mockOpenid,
          user: {
            id: '999', // 固定ID
            username: wxInfo.nickName || '模拟用户',
            avatar: wxInfo.avatarUrl || '',
            openid: mockOpenid
          }
        };
        
        // 保存openid到本地存储
        wx.setStorageSync('wx_openid', mockOpenid);
        
        console.log('使用模拟用户数据:', mockResponse);
        return Promise.resolve(mockResponse);
      }
      
      // 获取存储的openid，这是重要的身份标识
      const openid = wx.getStorageSync('wx_openid');
      
      // 准备登录请求数据，主要关注code和openid
      const requestData = {
        code: data.code,
        stored_openid: openid || '',
        userInfo: data.userInfo || {}
      };
      
      // 如果有用户信息，添加到请求中
      if (data.userInfo) {
        requestData.nickname = data.userInfo.nickName;
        requestData.avatar_url = data.userInfo.avatarUrl;
      }
      
      console.log('发送登录请求:', {
        code: requestData.code,
        stored_openid: requestData.stored_openid,
        has_userinfo: !!data.userInfo
      });
      
      // 发送登录请求
      return request('/login/wechat/', 'POST', requestData)
        .then(response => {
          console.log('登录响应:', response);
          
          if (!response || !response.user) {
            console.error('登录响应缺少用户信息');
            return Promise.reject(new Error('登录响应格式错误'));
          }
          
          // 用户信息
          const user = response.user;
          
          // 保存真实的openid，这是唯一的用户标识
          if (user.openid) {
            wx.setStorageSync('wx_openid', user.openid);
            console.log('保存微信openid:', user.openid);
          }
          
          // 保存token和用户信息
          wx.setStorageSync('token', response.token);
          wx.setStorageSync('userInfo', user);
          
          // 如果有微信用户信息，保存起来
          if (data.userInfo) {
            wx.setStorageSync('wx_profile_info', data.userInfo);
          }
          
          // 重置登录失败计数
          wx.removeStorageSync('login_fail_count');
          
          console.log('用户登录成功，ID:', user.id, '用户名:', user.username);
          return response;
        })
        .catch(err => {
          console.error('微信登录失败:', err);
          
          // 错误处理
          let errorMessage = '登录失败，请重试';
          
          if (err && err.data && err.data.error) {
            errorMessage = err.data.error;
          } else if (err && err.message) {
            errorMessage = err.message;
          }
          
          // 连续失败多次，建议清除缓存
          const loginFailCount = wx.getStorageSync('login_fail_count') || 0;
          wx.setStorageSync('login_fail_count', loginFailCount + 1);
          
          if (loginFailCount >= 3) {
            errorMessage += '。多次失败，建议清除缓存重试';
          }
          
          return Promise.reject({
            message: errorMessage,
            original: err
          });
        });
    },
    
    // 退出登录
    logout: () => {
      // 由于后端没有实现logout接口，直接清除本地会话信息但保留用户标识
      console.log('执行退出登录，清除本地会话信息');
      
      const app = getApp();
      if (app && app.clearLoginInfo) {
        // 使用app的clearLoginInfo方法，保留身份标识相关数据
        app.clearLoginInfo();
        console.log('已使用app.clearLoginInfo方法清除登录信息，保留了用户标识');
      } else {
        // 备用方案：直接清除token和用户信息
        console.log('app.clearLoginInfo不存在，使用备用方案清除登录信息');
        wx.removeStorageSync('token');
        wx.removeStorageSync('userInfo');
        
        if (app) {
          app.globalData.userInfo = null;
        }
      }
      
      // 返回成功的Promise
      return Promise.resolve({ success: true });
    },
    
    // 获取用户信息
    getInfo: () => {
      return authRequest('/user/info/', 'GET');
    }
  },
  
  // 首页数据
  home: {
    // 获取首页数据
    getData: () => {
      return request('/home/data/', 'GET');
    }
  },
  
  // 分类相关
  category: {
    // 获取所有分类
    getAll: () => {
      return request('/categories/', 'GET');
    },
    
    // 获取分类详情，包含食品
    getDetail: (id) => {
      return request(`/categories/${id}/?include_foods=true`, 'GET');
    }
  },
  
  // 食品相关
  food: {
    // 获取食品列表
    getList: (params = {}) => {
      // 构建查询参数
      let query = '';
      if (Object.keys(params).length > 0) {
        query = '?' + Object.keys(params)
          .map(key => `${key}=${encodeURIComponent(params[key])}`)
          .join('&');
      }
      
      return request(`/foods/${query}`, 'GET');
    },
    
    // 获取食品详情
    getDetail: (id) => {
      return request(`/foods/${id}/`, 'GET');
    },
    
    // 搜索食品
    search: (keyword) => {
      return request(`/foods/?keyword=${encodeURIComponent(keyword)}`, 'GET');
    }
  },
  
  // 购物车相关
  cart: {
    // 获取购物车列表
    getList: () => {
      return authRequest('/cart/', 'GET');
    },
    
    // 添加到购物车
    add: (data) => {
      return authRequest('/cart/', 'POST', data);
    },
    
    // 更新购物车项
    update: (id, data) => {
      console.log('调用购物车更新, 参数:', { id, data, argLength: arguments.length });
      
      try {
        // 直接检查参数类型并执行更新，不使用arguments.length
        if (typeof id === 'object' && id !== null && id.id) {
          // 情况1: update({id: 123, count: 2})
          const cartItemId = id.id;
          const { id: _, ...updateData } = id;
          return authRequest(`/cart/${cartItemId}/`, 'PATCH', updateData);
        } else if (typeof id !== 'undefined' && id !== null) {
          // 情况2: update(123, {count: 2})
          const cartItemId = id;
          const updateData = data || {};
          return authRequest(`/cart/${cartItemId}/`, 'PATCH', updateData);
        } else {
          return Promise.reject(new Error('缺少有效的购物车项ID'));
        }
      } catch (error) {
        console.error('购物车更新参数处理错误:', error);
        return Promise.reject(new Error(`参数处理异常: ${error.message}`));
      }
    },
    
    // 删除购物车项
    delete: (id) => {
      // 如果是对象，尝试获取id字段
      if (typeof id === 'object') {
        if (!id || !id.id) {
          return Promise.reject(new Error('缺少购物车项ID'));
        }
        id = id.id;
      }
      
      // 如果是直接传入ID，则直接使用
      return authRequest(`/cart/${id}/`, 'DELETE');
    },
    
    // 批量更新选中状态
    batchUpdate: (data) => {
      return authRequest('/cart/batch_update/', 'POST', data);
    },
    
    // 获取购物车汇总信息
    getSummary: () => {
      return authRequest('/cart/summary/', 'GET');
    }
  },
  
  // 地址相关
  address: {
    // 获取地址列表
    getList: () => {
      return authRequest('/addresses/', 'GET');
    },
    
    // 添加地址
    add: (data) => {
      return authRequest('/addresses/', 'POST', data);
    },
    
    // 更新地址
    update: (id, data) => {
      return authRequest(`/addresses/${id}/`, 'PATCH', data);
    },
    
    // 删除地址
    delete: (id) => {
      return authRequest(`/addresses/${id}/`, 'DELETE');
    }
  },
  
  // 订单相关
  order: {
    // 获取订单列表
    getList: (status = '') => {
      // 支持多状态查询，例如 "2,3"
      const query = status ? `?status=${status}` : '';
      return authRequest(`/orders/${query}`, 'GET');
    },
    
    // 获取订单详情
    getDetail: (id) => {
      return authRequest(`/orders/${id}/`, 'GET');
    },
    
    // 创建订单
    create: (data) => {
      return authRequest('/orders/', 'POST', data);
    },
    
    // 取消订单
    cancel: (id) => {
      return authRequest(`/orders/${id}/cancel/`, 'POST');
    },
    
    // 支付订单（模拟）
    pay: (id) => {
      return authRequest(`/orders/${id}/pay/`, 'POST');
    },
    
    // 确认收货
    receive: (id) => {
      return authRequest(`/orders/${id}/receive/`, 'POST');
    },
    
    // 完成订单
    complete: (id) => {
      return authRequest(`/orders/${id}/complete/`, 'POST');
    }
  }
};

module.exports = api; 